// pages/cart/cart.js
Page({

  /**
   * 页面的初始数据
   */
  data: {
    cartList: [
      {
        id: 1,
        name: '招牌奶茶',
        price: 18,
        image: '/images/products/product1.jpg',
        size: { id: 1, name: '中杯', price: 0 },
        sugar: { id: 1, name: '正常糖' },
        ice: { id: 1, name: '正常冰' },
        addon: [
          { id: 1, name: '珍珠', price: 2 }
        ],
        quantity: 1,
        itemTotal: 20
      },
      {
        id: 2,
        name: '芝芝芒果',
        price: 22,
        image: '/images/products/product2.jpg',
        size: { id: 2, name: '大杯', price: 2 },
        sugar: { id: 2, name: '少糖' },
        ice: { id: 2, name: '少冰' },
        addon: [],
        quantity: 2,
        itemTotal: 48
      }
    ],
    deliveryType: 'self', // self: 到店自取, delivery: 外卖配送
    totalAmount: 0, // 商品总价
    allSelected: true, // 是否全选
    selectedItems: {}, // 选中的商品ID映射
    addressInfo: {
      name: '张三',
      phone: '13812345678',
      address: '北京市朝阳区某某街道XX小区XX号'
    },
    selfPickupInfo: {
      shopName: '奶茶店总店',
      shopAddress: '北京市海淀区中关村大街1号',
      shopPhone: '010-12345678'
    },
    deliveryFee: 5, // 配送费
    isLoggedIn: false,
    openid: '',
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    // 获取购物车数据
    this.getCartData();

    // 获取默认收货地址
    this.getDefaultAddress();

    // 获取门店信息
    this.getShopInfo();

    // 检查登录状态
    this.checkLoginStatus();
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function () {
    // 每次显示页面时重新获取购物车数据
    this.getCartData();

    // 获取默认地址不需要调用，因为目前还没有实现该功能
    // 将其注释掉防止报错
    // this.getDefaultAddress();
    // this.getShopInfo();
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  },

  // 初始化选中状态
  initSelectedItems() {
    const selectedItems = {};
    const cartList = this.data.cartList || [];
    cartList.forEach(item => {
      if (item && item.id) {
        selectedItems[item.id] = true;
      }
    });

    this.setData({
      selectedItems
    });
  },

  // 计算总价
  calculateTotal() {
    const { cartList, selectedItems, deliveryType } = this.data;
    let totalAmount = 0;

    if (cartList && cartList.length > 0) {
      cartList.forEach(item => {
        if (item && selectedItems[item.id]) {
          totalAmount += (item.itemTotal || 0);
        }
      });
    }

    // 如果是外卖配送，加上配送费
    if (deliveryType === 'delivery') {
      totalAmount += this.data.deliveryFee || 0;
    }

    this.setData({
      totalAmount: Number(totalAmount).toFixed(2)
    });
  },

  // 切换商品选中状态
  toggleItemSelect(e) {
    const id = e.currentTarget.dataset.id;
    const selectedItems = { ...this.data.selectedItems };

    selectedItems[id] = !selectedItems[id];

    // 检查是否全选
    const allSelected = this.data.cartList.every(item => selectedItems[item.id]);

    this.setData({
      selectedItems,
      allSelected
    });

    this.calculateTotal();
  },

  // 切换全选状态
  toggleAllSelect() {
    const { allSelected, cartList } = this.data;
    const newAllSelected = !allSelected;
    const selectedItems = {};

    // 根据全选状态设置每个商品的选中状态
    if (cartList && cartList.length > 0) {
      cartList.forEach(item => {
        if (item && item.id) {
          selectedItems[item.id] = newAllSelected;
        }
      });
    }

    this.setData({
      allSelected: newAllSelected,
      selectedItems
    });

    this.calculateTotal();
  },

  // 获取购物车数据
  getCartData() {
    // 检查是否已登录，已登录则从云端获取
    const openid = wx.getStorageSync('openid');
    if (openid) {
      this.loadCartData();
    } else {
      // 未登录，只使用本地存储
      this.loadLocalCartData();
    }
  },

  // 加载本地购物车数据
  loadLocalCartData() {
    const cartStorage = wx.getStorageSync('cartList') || [];

    // 初始化购物车选中状态
    const selectedItems = {};
    cartStorage.forEach(item => {
      if (item && item.id) {
        selectedItems[item.id] = true;
      }
    });

    this.setData({
      cartList: cartStorage,
      selectedItems,
      allSelected: cartStorage.length > 0
    });

    // 计算总价
    this.calculateTotal();
  },

  // 增加商品数量
  increaseQuantity: function (e) {
    const id = e.currentTarget.dataset.id;
    const cartList = [...this.data.cartList];

    const index = cartList.findIndex(item => item.id === id);

    if (index > -1) {
      cartList[index].quantity += 1;

      this.setData({
        cartList
      });

      // 更新云端购物车数据
      this.updateCartToCloud(cartList);

      // 重新计算总价
      this.calculateTotal();

      // 原来的本地存储代码
      // wx.setStorageSync('cartList', cartList);
    }
  },

  // 减少商品数量
  decreaseQuantity: function (e) {
    const id = e.currentTarget.dataset.id;
    const cartList = [...this.data.cartList];

    const index = cartList.findIndex(item => item.id === id);

    if (index > -1 && cartList[index].quantity > 1) {
      cartList[index].quantity -= 1;

      this.setData({
        cartList
      });

      // 更新云端购物车数据
      this.updateCartToCloud(cartList);

      // 重新计算总价
      this.calculateTotal();

      // 原来的本地存储代码
      // wx.setStorageSync('cartList', cartList);
    }
  },

  // 计算单个商品的总价
  calculateItemTotal(item) {
    if (!item) return 0;

    let basePrice = item.price || 0;

    // 加上规格差价
    if (item.size && typeof item.size === 'object' && item.size.price) {
      basePrice += parseFloat(item.size.price) || 0;
    }

    // 加上配料价格
    let addonPrice = 0;
    if (item.addon && Array.isArray(item.addon) && item.addon.length > 0) {
      addonPrice = item.addon.reduce((sum, addon) => {
        return sum + (addon && addon.price ? parseFloat(addon.price) : 0);
      }, 0);
    }

    return (basePrice + addonPrice) * (item.quantity || 1);
  },

  // 删除商品
  deleteItem: function (e) {
    const id = e.currentTarget.dataset.id;
    let cartList = [...this.data.cartList];

    cartList = cartList.filter(item => item.id !== id);

    // 先更新UI，提高响应速度
    this.setData({
      cartList
    });

    // 更新本地存储
    wx.setStorageSync('cartList', cartList);

    // 显示加载提示
    wx.showLoading({
      title: '处理中...',
      mask: true
    });

    // 特殊处理购物车为空的情况
    if (cartList.length === 0) {
      console.log('购物车已清空');

      try {
        // 当购物车为空时，调用云函数更新云端数据
        wx.cloud.callFunction({
          name: 'updateCart',
          data: {
            items: []
          }
        })
          .then(() => {
            wx.hideLoading();
            wx.showToast({
              title: '已删除',
              icon: 'success'
            });

            // 重新计算总价和选中状态
            this.calculateTotal();
            this.checkAllSelected();
          })
          .catch(err => {
            wx.hideLoading();
            console.error('清空购物车失败:', err);

            wx.showToast({
              title: '已删除(本地)',
              icon: 'success'
            });

            // 重新计算总价和选中状态
            this.calculateTotal();
            this.checkAllSelected();
          });
      } catch (error) {
        wx.hideLoading();
        console.error('调用云函数异常:', error);

        wx.showToast({
          title: '已删除(本地)',
          icon: 'success'
        });

        // 重新计算总价和选中状态
        this.calculateTotal();
        this.checkAllSelected();
      }
    } else {
      // 购物车不为空，正常更新云端数据
      this.updateCartToCloud(cartList);

      // 重新计算总价和选中状态
      this.calculateTotal();
      this.checkAllSelected();

      wx.showToast({
        title: '已删除',
        icon: 'success'
      });
    }
  },

  // 切换配送方式
  switchDeliveryType(e) {
    const type = e.currentTarget.dataset.type;

    this.setData({
      deliveryType: type
    });

    this.calculateTotal();
  },

  // 去结算
  goToCheckout: function () {
    // 检查是否有选中的商品
    const hasSelectedItems = Object.values(this.data.selectedItems).some(value => value);

    if (!hasSelectedItems) {
      wx.showToast({
        title: '请选择商品',
        icon: 'none'
      });
      return;
    }

    // 获取选中的商品
    const selectedGoods = this.data.cartList.filter(item => this.data.selectedItems[item.id]);

    // 先保存到本地存储，确保数据不丢失
    wx.setStorageSync('selectedCartItems', selectedGoods);
    wx.setStorageSync('deliveryType', this.data.deliveryType);

    // 显示加载提示
    wx.showLoading({
      title: '准备中...',
      mask: true
    });

    // 同时尝试更新到云端（不阻塞跳转）
    try {
      wx.cloud.callFunction({
        name: 'updateCart',
        data: {
          selectedItems: selectedGoods
        }
      })
        .then(() => {
          console.log('已保存选中商品到云端');
        })
        .catch(err => {
          console.error('保存选中商品到云端失败:', err);
        })
        .finally(() => {
          wx.hideLoading();

          // 跳转到订单确认页
          wx.navigateTo({
            url: '/pages/order/order'
          });
        });
    } catch (error) {
      console.error('调用云函数异常:', error);
      wx.hideLoading();

      // 即使云端操作失败，仍然跳转到订单页
      wx.navigateTo({
        url: '/pages/order/order'
      });
    }
  },

  // 继续购物
  continueShopping() {
    wx.switchTab({
      url: '/pages/menu/menu'
    });
  },

  // 加载购物车数据 - 使用云函数
  loadCartData() {
    wx.showLoading({
      title: '加载中',
    });

    // 同时尝试从云端获取数据
    try {
      wx.cloud.callFunction({
        name: 'getCart',
        data: {
          openid: this.data.openid || ''
        }
      })
        .then(res => {
          wx.hideLoading();
          console.log('云端购物车数据:', res);

          if (res.result && res.result.success) {
            const cloudCartList = res.result.data || [];

            // 如果云端有数据且与本地不同，则使用云端数据
            if (cloudCartList.length > 0) {
              // 确保每个商品都有必要的属性
              const formattedCartList = cloudCartList.map(item => {
                return {
                  id: item.id || Math.random().toString(36).substring(2, 10),
                  name: item.name || '商品',
                  price: item.price || 0,
                  image: item.image || '/images/products/product1.jpg',
                  size: item.size || { id: 1, name: '常规', price: 0 },
                  sugar: item.sugar || { id: 1, name: '正常糖' },
                  ice: item.ice || { id: 1, name: '正常冰' },
                  addon: item.addon || [],
                  quantity: item.quantity || 1,
                  itemTotal: item.itemTotal || (item.price || 0)
                };
              });

              // 初始化购物车选中状态
              const selectedItems = {};
              formattedCartList.forEach(item => {
                selectedItems[item.id] = true;
              });

              this.setData({
                cartList: formattedCartList,
                selectedItems,
                allSelected: formattedCartList.length > 0
              });

              // 计算总价
              this.calculateTotal();

              // 更新本地存储，保持同步
              wx.setStorageSync('cartList', formattedCartList);
            } else {
              // 云端购物车为空，使用本地数据
              this.loadLocalCartData();
            }
          } else {
            // 获取失败，使用本地数据
            this.loadLocalCartData();
          }
        })
        .catch(err => {
          wx.hideLoading();
          console.error('获取购物车失败:', err);

          // 错误提示
          wx.showToast({
            title: '获取数据失败',
            icon: 'none'
          });

          // 使用本地数据
          this.loadLocalCartData();
        });
    } catch (error) {
      wx.hideLoading();
      console.error('云函数调用异常:', error);

      // 使用本地数据
      this.loadLocalCartData();
    }
  },

  // 更新购物车数据到云端
  updateCartToCloud(cartList) {
    console.log('准备更新购物车数据到云端');

    // 先更新本地存储，确保数据不丢失
    wx.setStorageSync('cartList', cartList);

    // 如果数据为空或无效，不进行云端更新
    if (!cartList || !Array.isArray(cartList) || cartList.length === 0) {
      console.log('购物车为空，不更新云端');
      return;
    }

    // 检查是否已登录
    if (!this.data.isLoggedIn) {
      console.log('用户未登录，仅保存到本地');
      return;
    }

    // 确保购物车中的每个商品都有必要属性
    const validCartList = cartList.filter(item => item && item.id);

    if (validCartList.length === 0) {
      console.log('没有有效商品，不更新云端');
      return;
    }

    // 确保每个商品都有总价
    const updatedCartList = validCartList.map(item => {
      if (!item.itemTotal || item.itemTotal <= 0) {
        item.itemTotal = this.calculateItemTotal(item);
      }
      return item;
    });

    // 显示更新指示
    wx.showLoading({
      title: '同步中',
      mask: true
    });

    try {
      // 调用云函数更新购物车
      wx.cloud.callFunction({
        name: 'updateCart',
        data: {
          items: updatedCartList,
          openid: this.data.openid
        }
      })
        .then(() => {
          wx.hideLoading();
        })
        .catch(err => {
          wx.hideLoading();
          console.error('更新购物车失败:', err);
        });
    } catch (error) {
      wx.hideLoading();
      console.error('云函数调用异常:', error);
    }
  },

  /**
   * 获取默认收货地址
   */
  getDefaultAddress: function () {
    try {
      const addressInfo = wx.getStorageSync('defaultAddress');
      if (addressInfo) {
        this.setData({
          addressInfo
        });
      }
    } catch (e) {
      console.error('获取默认地址失败', e);
    }
  },

  /**
   * 获取门店信息
   */
  getShopInfo: function () {
    // 这里可以实现从云开发获取门店信息
    // 目前使用默认值
    this.setData({
      selfPickupInfo: {
        shopName: '奶茶店总店',
        shopAddress: '北京市海淀区中关村大街1号',
        shopPhone: '010-12345678'
      }
    });
  },

  /**
   * 检查是否全选
   */
  checkAllSelected: function () {
    // 检查是否全选
    const allSelected = this.data.cartList.length > 0 &&
      this.data.cartList.every(item => this.data.selectedItems[item.id]);

    this.setData({
      allSelected
    });
  },

  /**
   * 检查登录状态
   */
  checkLoginStatus() {
    // 检查是否已登录
    const openid = wx.getStorageSync('openid');
    const userInfo = wx.getStorageSync('userInfo');

    this.setData({
      isLoggedIn: !!(openid && userInfo),
      openid: openid || ''
    });
  },
})